home *** CD-ROM | disk | FTP | other *** search
/ Acorn User: China / Acorn User China CD-ROM (UK) (Disc A) / Acorn User China CD-ROM (UK) (Disc A).bin / DEMON / MISC / NETLITE2.ARC / NET / c / FTP < prev    next >
Encoding:
Text File  |  1993-04-10  |  7.4 KB  |  216 lines
  1. /* Stuff common to both the FTP server and client */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include "werr.h"
  7. #include "global.h"
  8. #include "mbuf.h"
  9. #include "netuser.h"
  10. #include "timer.h"
  11. #include "tcp.h"
  12. #include "ftp.h"
  13. #include "session.h"
  14. #include "misc.h"
  15.  
  16. extern char nospace[];
  17.  
  18. /* FTP Data channel Receive upcall handler */
  19. void ftpdr(struct tcb *tcb, int16 cnt)
  20. {
  21.         struct session *current;
  22.         register struct ftp *ftp;
  23.         struct mbuf *bp;
  24.         register char *s;
  25.         register char *t;
  26.         register int i;
  27.         char *line;
  28.         int hashes, n;
  29.  
  30.         ftp = (struct ftp *)tcb->user;
  31.         if (ftp->state != RECEIVING_STATE) {
  32.                 close_tcp(tcb);
  33.                 return;
  34.         }
  35.         for(i = 0; i < nsessions; i++){
  36.                 if(sessions[i].type == FTP && sessions[i].cb.ftp == ftp){
  37.                         current = sessions + i;
  38.                         break;
  39.                 }
  40.         }
  41.         /* This will likely also generate an ACK with window rotation */
  42.         if (recv_tcp(tcb, &bp, cnt) > 0) {
  43.                 hashes = ftp->bytes / 1024;
  44.                 ftp->bytes += len_mbuf(bp);
  45.                 n = ftp->bytes / 1024 - hashes;
  46.                 if (ftp->hash)
  47.                         for (i = 0; i < n; i++)
  48.                                Window_Write(ftp->session->window,"#",1);
  49.                 if ((line = s = malloc(len_mbuf(bp) + 1)) == NULL)
  50.                 {
  51.                         werr(0,nospace);
  52.                         free_p(bp);
  53.                         return;
  54.                 }
  55.                 while (bp != NULLBUF) {
  56.                         t = bp->data;
  57.                         while (bp->cnt-- > 0) {
  58.                                 if (ftp->type == ASCII_TYPE) {
  59.                                         if (*t != '\r')
  60.                                                 *s++ = *t;
  61.                                 } else {
  62.                                         *s++ = *t;
  63.                                 }
  64.                                 t++;
  65.                         }
  66.                         bp = free_mbuf(bp);
  67.                 }
  68.                 if (ftp->fp == stdout)
  69.                         Window_Write(current->window, line, s - line);
  70.                 else
  71.                         fwrite(line, 1, s - line, ftp->fp);
  72.                 free(line);
  73.         }
  74. }
  75. /* FTP Data channel Transmit upcall handler */
  76. void ftpdt(struct tcb *tcb, int16 cnt)
  77. {
  78.         struct ftp *ftp;
  79.         struct mbuf *bp;
  80.         register char *cp;
  81.         register int c;
  82.         int eof_flag;
  83.         int hashes, n, i;
  84.  
  85.         ftp = (struct ftp *)tcb->user;
  86.         if(ftp->state != SENDING_FILE_STATE && ftp->state != SENDING_DATA_STATE){
  87.                 close_tcp(tcb);
  88.                 return;
  89.         }
  90.         if((bp = alloc_mbuf(cnt)) == NULLBUF){
  91.                 /* Hard to know what to do here */
  92.                 return;
  93.         }
  94.         eof_flag = 0;
  95.         if (ftp->state == SENDING_FILE_STATE) {
  96.                 if(ftp->type == IMAGE_TYPE){
  97.                         bp->cnt = fread(bp->data,1,cnt,ftp->fp);
  98.                         if(bp->cnt != cnt)
  99.                                 eof_flag = 1;
  100.                 } else {
  101.                         cp = bp->data;
  102.                         while(cnt > 1){
  103.                                 if((c = getc(ftp->fp)) == EOF){
  104.                                         eof_flag=1;
  105.                                         break;
  106.                                 }
  107.                                 if(c == '\n'){
  108.                                         *cp++ = '\r';
  109.                                         bp->cnt++;
  110.                                         cnt--;
  111.                                 }
  112.                                 *cp++ = c;
  113.                                 bp->cnt++;
  114.                                 cnt--;
  115.                         }
  116.                 }
  117.                 hashes = ftp->bytes / 1024;
  118.                 ftp->bytes += len_mbuf(bp);
  119.                 n = ftp->bytes / 1024 - hashes;
  120.                 if (ftp->hash)
  121.                         for (i = 0; i < n; i++)
  122.                                 Window_Write(ftp->session->window,"#",1);
  123.                 if(bp->cnt != 0)
  124.                         send_tcp(tcb,bp);
  125.                 else
  126.                         free_p(bp);
  127.                 if(eof_flag){   /* EOF seen */
  128.                         fclose(ftp->fp);
  129.                         ftp->fp = NULLFILE;
  130.                         close_tcp(tcb);
  131.                 }
  132.         } else {        /* SENDING_DATA_STATE */
  133.                 if(ftp->type == IMAGE_TYPE){
  134.                         if ((bp->cnt = strlen(ftp->cp)) < cnt)
  135.                                 eof_flag = 1;
  136.                         else
  137.                                 bp->cnt = cnt;
  138.                         strncpy(bp->data, ftp->cp, bp->cnt);
  139.                         bp->data[bp->cnt] = '\0';
  140.                         ftp->cp += bp->cnt;
  141.                 } else {
  142.                         cp = bp->data;
  143.                         while(cnt > 1){
  144.                                 if((c = *ftp->cp++) == '\0'){
  145.                                         c = EOF;
  146.                                         eof_flag=1;
  147.                                         break;
  148.                                 }
  149.                                 if(c == '\n'){
  150.                                         *cp++ = '\r';
  151.                                         bp->cnt++;
  152.                                         cnt--;
  153.                                 }
  154.                                 *cp++ = c;
  155.                                 bp->cnt++;
  156.                                 cnt--;
  157.                         }
  158.                 }
  159.                 hashes = ftp->bytes / 1024;
  160.                 ftp->bytes += len_mbuf(bp);
  161.                 n = ftp->bytes / 1024 - hashes;
  162.                 if (ftp->hash)
  163.                         for (i = 0; i < n; i++)
  164.                                 Window_Write(ftp->session->window,"#",1);
  165.                 if(bp->cnt != 0)
  166.                         send_tcp(tcb,bp);
  167.                 else
  168.                         free_p(bp);
  169.                 if(eof_flag){   /* EOF seen */
  170.                         free(ftp->p);
  171.                         ftp->p = ftp->cp = NULLCHAR;
  172.                         close_tcp(tcb);
  173.                 }
  174.         }
  175. }
  176. /* Allocate an FTP control block */
  177. struct ftp *ftp_create(unsigned int bufsize)
  178. {
  179.         register struct ftp *ftp;
  180.  
  181.         if((ftp = (struct ftp *)calloc(1,sizeof (struct ftp))) == NULLFTP)
  182.                 return NULLFTP;
  183.         if(bufsize != 0 && (ftp->buf = malloc(bufsize)) == NULLCHAR){
  184.                 ftp_delete(ftp);
  185.                 return NULLFTP;
  186.         }
  187.         ftp->state = COMMAND_STATE;
  188.         ftp->type = ASCII_TYPE; /* Default transfer type */
  189.         return ftp;
  190. }
  191. /* Free resources, delete control block */
  192. void ftp_delete(register struct ftp *ftp)
  193. {
  194.         int i;
  195.  
  196.         if(ftp->fp != NULLFILE && ftp->fp != stdout)
  197.                 fclose(ftp->fp);
  198.         if(ftp->p != NULLCHAR)
  199.                 free(ftp->p);
  200.         if(ftp->data != NULLTCB)
  201.                 del_tcp(ftp->data);
  202.         if(ftp->username != NULLCHAR)
  203.                 free(ftp->username);
  204.         for (i = 0; i < MAXPATH; i++)
  205.                 if(ftp->path[i] != NULLCHAR)
  206.                         free(ftp->path[i]);
  207.         if(ftp->buf != NULLCHAR)
  208.                 free(ftp->buf);
  209.         if(ftp->cd != NULLCHAR)
  210.                 free(ftp->cd);
  211.         if(ftp->session != NULLSESSION)
  212.                 detachsession(ftp->session);
  213.         free((char *)ftp);
  214. }
  215.  
  216.